{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T09:53:52.567505Z",
     "start_time": "2025-01-09T09:53:52.563633Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 1.1 特征中含有字符串的时候（当成类别），如何做特征抽取",
   "id": "8aa5e803a292ffb5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T09:57:45.145285Z",
     "start_time": "2025-01-09T09:57:45.138285Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "fit_transform()方法     用于训练集\n",
    "(1)通常用于在训练阶段（training phase）对数据进行拟合（fitting）和转换（transforming）。\n",
    "(2)在使用 fit_transform() 方法时，模型会对数据进行拟合学习，然后将学到的知识应用于数据转换。\n",
    "(3)这个方法将对数据进行拟合和转换，并且返回转换后的数据。通常在训练集上使用这个方法。\n",
    "\n",
    "transform()方法     用于测试集\n",
    "（1）用于对数据进行转换，但不进行拟合。\n",
    "（2）它通常在训练阶段拟合好模型后，在测试集或新数据上进行转换时使用。这是因为在测试集或新数据上不需要重新拟合模型，只需要应用之前学到的转换规则即可。\n",
    "（3）这个方法会根据之前在训练集上学到的规则来对数据进行转换，返回转换后的数据。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def dict_vectorizer():\n",
    "    # DicVectorizer 是一个字典特征抽取器，可以将字典形式的特征转换为向量形式\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    # sparse改为False,若有n个向量，则生成(n,m)矩阵，m>n\n",
    "    #                (n,n)矩阵表示是哪组数据，后面(m-n)列用于属性\n",
    "    # 矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    # Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=False)\n",
    "\n",
    "    # fit_transform()方法可以将字典形式的特征转换为向量形式\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100, 'humidity': 80},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30},\n",
    "                                {'city': '合肥', 'temperature': 38},\n",
    "                                {'city': '武汉', 'temperature': 30}])\n",
    "\n",
    "    print(\"这是数据data\")\n",
    "    print(data)\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # get_feature_names_out()方法可以获取字典形式的特征的名称\n",
    "    print(dict1.get_feature_names_out())\n",
    "    # ['city=上海' 'city=北京' 'city=合肥' 'city=武汉' 'city=深圳' 'humidity' 'temperature']\n",
    "    print(type(dict1.get_feature_names_out()))  # <class 'numpy.ndarray'>\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    #去看每个特征代表的含义，逆转回去\n",
    "    print(dict1.inverse_transform(data))\n",
    "\n",
    "\n",
    "dict_vectorizer()"
   ],
   "id": "da289c63f83dcf24",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "这是数据data\n",
      "[[  0.   1.   0.   0.   0.  80. 100.]\n",
      " [  1.   0.   0.   0.   0.   0.  60.]\n",
      " [  0.   0.   0.   0.   1.   0.  30.]\n",
      " [  0.   0.   1.   0.   0.   0.  38.]\n",
      " [  0.   0.   0.   1.   0.   0.  30.]]\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=合肥' 'city=武汉' 'city=深圳' 'humidity'\n",
      " 'temperature']\n",
      "<class 'numpy.ndarray'>\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'humidity': np.float64(80.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}, {'city=合肥': np.float64(1.0), 'temperature': np.float64(38.0)}, {'city=武汉': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 1.2 一段英文文本如何变为数值类型",
   "id": "f649a318f471f14c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T10:41:26.114436Z",
     "start_time": "2025-01-09T10:41:26.107759Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def count_vectorizer():\n",
    "    # CountVectorizer 是一个计数特征抽取器，可以将文本数据转换为向量形式\n",
    "    # 实例化\n",
    "    # 输入参数：\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于 等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # fit_transform()方法可以将文本数据转换为向量形式\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    print(\"这是文本单词\")\n",
    "    # get_feature_names_out()方法可以获取文本数据中所有词的名称\n",
    "    print(vector.get_feature_names_out())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # toarray()方法可以将矩阵形式的特征转换为数组形式\n",
    "    # 行向量表示一句话，每列数字表示该句话中的该单词出现几次\n",
    "    print(res.toarray())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(res)\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(type(res))\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # 拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "count_vectorizer()"
   ],
   "id": "8f6edb178579311c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "这是文本单词\n",
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 一段汉字文本如何数值化，对于汉字不能用空格来分割",
   "id": "cc0e87417570d3e5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T10:44:57.649553Z",
     "start_time": "2025-01-09T10:44:57.643232Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def count_vectorizer_chinese():\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\",\n",
    "                             \"人生漫长，不用 python\"])\n",
    "\n",
    "    # 简单地对中文句子用空格来划分得到的结果无意义\n",
    "    print(cv.get_feature_names_out())\n",
    "    print(\"-\" * 50)\n",
    "    print(data.toarray())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(data)\n",
    "\n",
    "\n",
    "count_vectorizer_chinese()\n"
   ],
   "id": "6390db95548d5ee8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n"
     ]
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 1.3 掌握如何对中文进行分词",
   "id": "72bf2edba3916104"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:13:02.608298Z",
     "start_time": "2025-01-09T11:13:02.600198Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def jieba_cut_words():\n",
    "    # jieba 是一个中文分词工具包，可以将中文文本进行分词\n",
    "    # jieba.cut()方法可以将中文文本进行分词,返回一个可迭代的generator\n",
    "    con1 = jieba.cut(\n",
    "        \"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # print(type(con1))  # <class 'generator'> 是一个可迭代的generator\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # 将generator转换为list\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    # print(content1)\n",
    "    # print(content2)\n",
    "    # print(content3)\n",
    "    # print(\"-\" * 50)\n",
    "\n",
    "    # 把列表转换成字符串，每个词之间用空格隔开\n",
    "    # join()方法可以将列表中的元素用指定的字符连接成一个字符串\n",
    "    str1 = \" \".join(content1)\n",
    "    str2 = \" \".join(content2)\n",
    "    str3 = \" \".join(content3)\n",
    "\n",
    "    return str1, str2, str3  # 返回三个字符串\n",
    "\n",
    "\n",
    "def count_vectorizer_chinese_cut():\n",
    "    str1, str2, str3 = jieba_cut_words()  # 得到处理好的字符串\n",
    "\n",
    "    vector = CountVectorizer()\n",
    "    data = vector.fit_transform([str1, str2, str3])\n",
    "\n",
    "    # 把处理好后的特征名称打印出来\n",
    "    print(vector.get_feature_names_out())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "\n",
    "# jieba_cut_words()\n",
    "count_vectorizer_chinese_cut()"
   ],
   "id": "a3dbfc75a66e6b67",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 1.4 tf-idf",
   "id": "fa1dcab4542bcf0f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:15:27.161303Z",
     "start_time": "2025-01-09T11:15:27.153030Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "在使用 TfidfVectorizer 转换文本数据后，得到的数组元素值代表了每个单词（特征）在每个文档中的 TF-IDF 权重值。\n",
    "\n",
    "(1) TF-IDF（Term Frequency-Inverse Document Frequency）权重：TF-IDF 是一个用于评估一个单词在文档集合中的重要性的统计方法。\n",
    "    由两部分组成：TF（词频）和 IDF（逆文档频率）。\n",
    "    TF 表示某个词在文档中出现的频率，而 IDF 表示某个词的稀有程度，即它在文档集合中出现的文档数的倒数的对数值。\n",
    "(2) 数组元素值的含义：在 TfidfVectorizer 转换后得到的数组中，每个元素代表了一个单词在一个文档中的 TF-IDF 值。\n",
    "    这个值越大，表示这个单词在这个文档中的重要性越高。\n",
    "    如果某个词在某个文档中出现频繁（TF 高），但在整个文档集合中出现较少（IDF 高），那么它的 TF-IDF 值会相对较高。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def tfidfvec():\n",
    "    # TfidfVectorizer 是一个tf-idf特征抽取器，可以将文本数据转换为向量形式\n",
    "\n",
    "    str1, str2, str3 = jieba_cut_words()  # 得到处理好的字符串\n",
    "    print(str1)\n",
    "    print(str2)\n",
    "    print(str3)\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # smooth_idf布尔值，默认 = True\n",
    "    # 如果 smooth_idf=True，则计算tf-idf时会添加一个平滑系数，避免分母为0\n",
    "    # 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "    # 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零， log(n/n(x)),从而出现零分裂\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "    data = tf.fit_transform([str1, str2, str3])\n",
    "\n",
    "    # get_feature_names_out()方法可以获取文本数据中所有词的名称\n",
    "    print(tf.get_feature_names_out())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(data.toarray())\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "id": "811283d6d8751840",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2 特征处理，不同的特征拉到到同一个量纲",
   "id": "bf5485b9541253d2"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:36:45.319746Z",
     "start_time": "2025-01-09T11:36:45.313700Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "归一化：\n",
    "    将数据映射到同一个量纲，如将数据映射到[0,1]之间，或者[-1,1]之间。、\n",
    "    计算方法： \n",
    "    MinMaxScaler：将数据映射到[0,1]之间，公式为：\n",
    "    f(x)=(x-min)/(max-min)  \n",
    "    作用于每一列，max为一列的最大值，min为一列的最小值,那么f(x)为最终结果，\n",
    "    \n",
    "    缺点：容易受极值的影响\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def min_max_scaler():\n",
    "    # MinMaxScaler 是一个归一化器，可以将数据映射到[0,1]之间\n",
    "    # feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "\n",
    "\n",
    "min_max_scaler()\n",
    "print((1 - 60) / (90 - 60))"
   ],
   "id": "4a37861582aee5cb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n",
      "-1.9666666666666666\n"
     ]
    }
   ],
   "execution_count": 50
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:52:00.397464Z",
     "start_time": "2025-01-09T11:52:00.391612Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "标准化：\n",
    "    通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内\n",
    "    注意：不是标准正态分布，只是均值为0，标准差为1的均匀分布\n",
    "\n",
    "    计算方法：\n",
    "    StandardScaler：\n",
    "    f(x)=(X-EX)/（DX^0.5)  EX为一列的均值,DX为一列的方差 \n",
    "    \n",
    "    对于归一化来说：如果出现异常点，影响了最大值和最小值，那么结果显然\n",
    "\t\t会发生改变\n",
    "\n",
    "    对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对\n",
    "\t\t于平均值的影响并不大，从而方差改变较小。\n",
    "    \n",
    "    在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def standard_scaler():\n",
    "    # StandardScaler 是一个标准化器，可以将数据映射到均值为0,标准差为1范围内\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print(\"-\" * 50)\n",
    "    print(type(data))  # numpy.ndarray\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(std.mean_)  # 每一列的均值\n",
    "    print(std.var_)  # 每一列的方差\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "\n",
    "\n",
    "standard_scaler()"
   ],
   "id": "df548b663a5ecb95",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "<class 'numpy.ndarray'>\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "--------------------------------------------------\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 53
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:55:19.436941Z",
     "start_time": "2025-01-09T11:55:19.430870Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 为了证明上面输出的结果的均值是为0的，方差为1\n",
    "\n",
    "std_text = StandardScaler()\n",
    "data_text = std_text.fit_transform([[-1.06904497, - 1.35873244, 0.98058068],\n",
    "                                    [-0.26726124, 0.33968311, 0.39223227],\n",
    "                                    [1.33630621, 1.01904933, - 1.37281295]])\n",
    "\n",
    "print(std_text.mean_)\n",
    "print(std_text.var_)\n",
    "# 得证，每列的均值是0，方差是1"
   ],
   "id": "b397c559e146152f",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 55
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差",
   "id": "31fd8dffe331d68b"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 3 缺失值处理",
   "id": "c2b8a0bd46b2035a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:02:39.256683Z",
     "start_time": "2025-01-09T12:02:39.250690Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "\n",
    "def imputer():\n",
    "    # SimpleImputer 是一个缺失值填补器，可以将缺失值填补为指定值\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    # 可替换选项：mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6]])\n",
    "    print(data)\n",
    "\n",
    "\n",
    "imputer()"
   ],
   "id": "5561aeaa49e9c4b4",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [4. 3.]\n",
      " [7. 6.]]\n"
     ]
    }
   ],
   "execution_count": 57
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "## 降维就是特征数变少\n",
    "## 降维可以提高模型训练速度（特征变少）"
   ],
   "id": "9cddd55111ab7b86"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:16:24.345157Z",
     "start_time": "2025-01-09T12:16:24.338672Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "Filter(过滤式):VarianceThreshold\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def variance_threshold():\n",
    "    # VarianceThreshold 是一个过滤器\n",
    "    # 返回值：训练集差异低于threshold的特征将被删除。\n",
    "    # 默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。\n",
    "    var = VarianceThreshold(threshold=0.1)  # 保留方差大于0.1的特征\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print(\"-\" * 50)\n",
    "    print(var.get_support())  # 保留的特征的索引\n",
    "\n",
    "\n",
    "variance_threshold()\n"
   ],
   "id": "1b965fbe5f6c60e9",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "[False  True  True False]\n"
     ]
    }
   ],
   "execution_count": 58
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:35:19.801425Z",
     "start_time": "2025-01-09T12:35:19.792934Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "PCA():\n",
    "目的：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。\n",
    "作用：可以削减回归分析或者聚类分析中特征的数量\n",
    "用途：特征数量达到上百的时候，开始使用PCA\n",
    "\n",
    "原理（几何方式）：\n",
    "     假设将二维数据进行降维：\n",
    "     将所有点画在同一个坐标系上，然后找出一条直线l，使得这条直线尽可能的贴近所有点。\n",
    "     从所有点作直线l的垂线，垂线的交点相对于直线l的位置就是新的坐标轴。\n",
    "     高维依次类推\n",
    "     \n",
    "特点：不稳定\n",
    "原因：(1)数据归一化的方式不同:对于PCA来说，数据的归一化可以采用标准化或者最大最小值归一化等方法。不同的归—化方式会导致不同的结果。\n",
    "     (2)特征值计算的精度:在特征值计算算精度也可能会影响结果的稳定\n",
    "性。\n",
    "     (3)特征值相同时的特征向量计算:如征向量的计算就不唯一了,不同的计算方式也会导致结果不同。\n",
    "     (4)随机选择初始向量:在迭代计算特征向量的过程中，需要随机选择一个初始向量，这也可能会导致结果不稳定。\n",
    "\n",
    "为了提高结果的稳定性，可以采用多次运行PCA并取平均值的方法。另外，在进行PCA之前，可以对数据进行多次重复采样，然后对每次采样得到的数据进行PCA分析，以进一步提高结果的可靠性。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def pca():\n",
    "    origin_data = np.array([[2, 8, 4, 5],\n",
    "                            [6, 3, 0, 8],\n",
    "                            [5, 4, 9, 1]])\n",
    "    print(np.var(origin_data, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    # PCA 是一个降维器\n",
    "    # n_components：指定降维后的维数，可以是int或者float\n",
    "    # 如果n_components是int，则表示降维后的维数，\n",
    "    # 如果是float，则表示降维后的方差贡献率，取值范围为0-1 业界选择 90~95%\n",
    "    # 如果n_components大于原始数据的维数，则等价于不降维\n",
    "    pca = PCA(n_components=0.9)\n",
    "    data = pca.fit_transform(origin_data)\n",
    "\n",
    "    print(data)\n",
    "    print(\"-\" * 50)\n",
    "    print(type(data))  # numpy.ndarray\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(np.var(data, axis=0).sum())  #降维后每一列的方差，求和\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(pca.explained_variance_ratio_)  # 方差贡献率\n",
    "    print(\"-\" * 50)\n",
    "\n",
    "    print(pca.explained_variance_ratio_.sum())  # 方差贡献率之和\n",
    "    \n",
    "\n",
    "pca()"
   ],
   "id": "739551e28142ee16",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "--------------------------------------------------\n",
      "<class 'numpy.ndarray'>\n",
      "--------------------------------------------------\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "--------------------------------------------------\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 64
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:39:45.338658Z",
     "start_time": "2025-01-09T12:39:45.225621Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x=np.random.rand(10000) # 生成10000个随机数\n",
    "t=np.arange(len(x))\n",
    "\n",
    "# g. 代表绿色圆点，代表均匀分布\n",
    "# label=\"Uniform Distribution\" 代表图例名称\n",
    "plt.plot(t,x,\"g.\",label=\"Uniform Distribution\")\n",
    "\n",
    "plt.legend(loc=\"best\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "id": "7cbd6175709f4e9a",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 69
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
